In [53]:
import numpy as np # linear algebra
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import tensorflow as tf
from PIL import Image
from keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.models import Sequential
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout, ReLU, MaxPool2D, GlobalAvgPool2D
from tensorflow.keras.layers import Input, Add, ZeroPadding2D, Activation, BatchNormalization, Flatten, Conv2D, AveragePooling2D, GlobalMaxPooling2D, GlobalAveragePooling2D
from tensorflow.keras.initializers import glorot_uniform
from tensorflow.keras.models import Model
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import OneHotEncoder

Data Preprocessing¶

In [54]:
supp_dir = '/kaggle/input/ubc-ovarian-cancer-competition-supplemental-masks'
data_dir = '/kaggle/input/UBC-OCEAN'

train_csv = pd.read_csv(data_dir + '/train.csv')
test_csv = pd.read_csv(data_dir + '/test.csv')
In [55]:
#filter for WSI
train_csv = train_csv[train_csv['is_tma'] == False]
train_data, val_data = train_test_split(train_csv, test_size=0.2, random_state=42)

#image paths
train_image_paths = [data_dir + '/train_thumbnails/' + str(img_id) + '_thumbnail.png' for img_id in train_data['image_id']]
val_image_paths = [data_dir + '/train_thumbnails/' + str(img_id) + '_thumbnail.png' for img_id in val_data['image_id']]
test_image_paths = [data_dir + '/test_thumbnails/' + str(img_id) + '_thumbnail.png' for img_id in test_csv['image_id']]

#multi-class classification: encoding labels for model (one-hot encoding)
one_hot_encoder = OneHotEncoder(sparse_output=False)

# Reshape the labels to a 2D array before applying OneHotEncoder
train_labels = np.array(train_data['label'])
val_labels = np.array(val_data['label'])

train_labels_reshaped = train_labels.reshape(-1, 1)
val_labels_reshaped = val_labels.reshape(-1, 1)

train_labels_one_hot = one_hot_encoder.fit_transform(train_labels_reshaped)
val_labels_one_hot = one_hot_encoder.transform(val_labels_reshaped)


#print(test_labels_one_hot)
#print(val_labels_one_hot)
In [56]:
#(1) feature scales first (all pixel values are now between 0 and 1), image augmentation transforms (shear_range, zoom_range, horizontal_flip) to prevent overfitting
datagen = ImageDataGenerator(rescale = 1./255,
                                   shear_range = 0.2,
                                   #zoom_range = 0.2,
                                   horizontal_flip = True
                            )

def load_and_augment_img(img_path):
    img = Image.open(img_path)
    img = img.resize((224, 224))  # Resize to desired dimensions
    img = np.array(img)  # Convert to numpy array
    img = img.reshape((1,) + img.shape)  # Reshape to (1, height, width, channels) for flow()
    img = datagen.flow(img, batch_size=1).next()  # Apply data augmentation
    return img[0]

# Apply data augmentation to training, validation, and test images
train_images_augmented = [load_and_augment_img(path) for path in train_image_paths]
val_images_augmented = [load_and_augment_img(path) for path in val_image_paths]
test_images_augmented = [load_and_augment_img(path) for path in test_image_paths]
In [57]:
import matplotlib.pyplot as plt
def visualize(image):
    plt.figure(figsize=(10, 10))
    plt.axis('off')
    plt.imshow(image)
In [58]:
from IPython.display import Image
Image(filename=train_image_paths[0], width=768, height=768) 
Out[58]:
No description has been provided for this image
In [59]:
visualize(train_images_augmented[0])
No description has been provided for this image

Define ResNet-50 Architecture¶

In [60]:
unique_classes = np.unique(train_labels)
uni_classes = list(unique_classes)
length = len(unique_classes)

print(uni_classes)
['CC', 'EC', 'HGSC', 'LGSC', 'MC']
In [61]:
input_tensor = (224, 224, 3)
NUMBER_OF_CLASSES = 5
In [62]:
# DEFINE THE RESNET-50 ARCHITECTURE *************************************************************

def conv_batchnorm_relu(x, filters, kernel_size, strides=1):
    x = Conv2D(filters=filters, kernel_size=kernel_size, strides=strides, padding = 'same')(x)
    x = BatchNormalization()(x)
    x = ReLU()(x)
    return x

def identity_block(tensor, filters):
    x = conv_batchnorm_relu(tensor, filters=filters, kernel_size=1, strides=1)
    x = conv_batchnorm_relu(x, filters=filters, kernel_size=3, strides=1)
    x = Conv2D(filters=4*filters, kernel_size=1, strides=1)(x)
    x = BatchNormalization()(x)
    x = Add()([tensor,x]) 
    x = ReLU()(x)
    return x

def projection_block(tensor, filters, strides):
    x = conv_batchnorm_relu(tensor, filters=filters, kernel_size=1, strides=strides)     
    x = conv_batchnorm_relu(x, filters=filters, kernel_size=3, strides=1)     
    x = Conv2D(filters=4*filters, kernel_size=1, strides=1)(x)     
    x = BatchNormalization()(x) 
    shortcut = Conv2D(filters=4*filters, kernel_size=1, strides=strides)(tensor)     
    shortcut = BatchNormalization()(shortcut)          
    x = Add()([shortcut,x])       
    x = ReLU()(x)          
    return x 
    
def resnet_block(x, filters, reps, strides):
    x = projection_block(x, filters, strides)
    for _ in range(reps-1):
        x = identity_block(x,filters)
    return x 
In [63]:
input = Input(shape=input_tensor)


x = conv_batchnorm_relu(input, filters=64, kernel_size=7, strides=2)
x = MaxPool2D(pool_size=3, strides=2)(x)
x = resnet_block(x, filters=64, reps=3, strides=1)
x = resnet_block(x, filters=128, reps=4, strides=2)
x = resnet_block(x, filters=256, reps=6, strides=2)
x = resnet_block(x, filters=512, reps=3, strides=2)
x = GlobalAvgPool2D()(x)


output = Dense(NUMBER_OF_CLASSES, activation ='softmax')(x)


model = Model(inputs=input, outputs=output)
In [64]:
model.summary()
Model: "model_3"
__________________________________________________________________________________________________
 Layer (type)                Output Shape                 Param #   Connected to                  
==================================================================================================
 input_4 (InputLayer)        [(None, 224, 224, 3)]        0         []                            
                                                                                                  
 conv2d_159 (Conv2D)         (None, 112, 112, 64)         9472      ['input_4[0][0]']             
                                                                                                  
 batch_normalization_159 (B  (None, 112, 112, 64)         256       ['conv2d_159[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_147 (ReLU)            (None, 112, 112, 64)         0         ['batch_normalization_159[0][0
                                                                    ]']                           
                                                                                                  
 max_pooling2d_3 (MaxPoolin  (None, 55, 55, 64)           0         ['re_lu_147[0][0]']           
 g2D)                                                                                             
                                                                                                  
 conv2d_160 (Conv2D)         (None, 55, 55, 64)           4160      ['max_pooling2d_3[0][0]']     
                                                                                                  
 batch_normalization_160 (B  (None, 55, 55, 64)           256       ['conv2d_160[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_148 (ReLU)            (None, 55, 55, 64)           0         ['batch_normalization_160[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_161 (Conv2D)         (None, 55, 55, 64)           36928     ['re_lu_148[0][0]']           
                                                                                                  
 batch_normalization_161 (B  (None, 55, 55, 64)           256       ['conv2d_161[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_149 (ReLU)            (None, 55, 55, 64)           0         ['batch_normalization_161[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_163 (Conv2D)         (None, 55, 55, 256)          16640     ['max_pooling2d_3[0][0]']     
                                                                                                  
 conv2d_162 (Conv2D)         (None, 55, 55, 256)          16640     ['re_lu_149[0][0]']           
                                                                                                  
 batch_normalization_163 (B  (None, 55, 55, 256)          1024      ['conv2d_163[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 batch_normalization_162 (B  (None, 55, 55, 256)          1024      ['conv2d_162[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 add_48 (Add)                (None, 55, 55, 256)          0         ['batch_normalization_163[0][0
                                                                    ]',                           
                                                                     'batch_normalization_162[0][0
                                                                    ]']                           
                                                                                                  
 re_lu_150 (ReLU)            (None, 55, 55, 256)          0         ['add_48[0][0]']              
                                                                                                  
 conv2d_164 (Conv2D)         (None, 55, 55, 64)           16448     ['re_lu_150[0][0]']           
                                                                                                  
 batch_normalization_164 (B  (None, 55, 55, 64)           256       ['conv2d_164[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_151 (ReLU)            (None, 55, 55, 64)           0         ['batch_normalization_164[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_165 (Conv2D)         (None, 55, 55, 64)           36928     ['re_lu_151[0][0]']           
                                                                                                  
 batch_normalization_165 (B  (None, 55, 55, 64)           256       ['conv2d_165[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_152 (ReLU)            (None, 55, 55, 64)           0         ['batch_normalization_165[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_166 (Conv2D)         (None, 55, 55, 256)          16640     ['re_lu_152[0][0]']           
                                                                                                  
 batch_normalization_166 (B  (None, 55, 55, 256)          1024      ['conv2d_166[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 add_49 (Add)                (None, 55, 55, 256)          0         ['re_lu_150[0][0]',           
                                                                     'batch_normalization_166[0][0
                                                                    ]']                           
                                                                                                  
 re_lu_153 (ReLU)            (None, 55, 55, 256)          0         ['add_49[0][0]']              
                                                                                                  
 conv2d_167 (Conv2D)         (None, 55, 55, 64)           16448     ['re_lu_153[0][0]']           
                                                                                                  
 batch_normalization_167 (B  (None, 55, 55, 64)           256       ['conv2d_167[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_154 (ReLU)            (None, 55, 55, 64)           0         ['batch_normalization_167[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_168 (Conv2D)         (None, 55, 55, 64)           36928     ['re_lu_154[0][0]']           
                                                                                                  
 batch_normalization_168 (B  (None, 55, 55, 64)           256       ['conv2d_168[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_155 (ReLU)            (None, 55, 55, 64)           0         ['batch_normalization_168[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_169 (Conv2D)         (None, 55, 55, 256)          16640     ['re_lu_155[0][0]']           
                                                                                                  
 batch_normalization_169 (B  (None, 55, 55, 256)          1024      ['conv2d_169[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 add_50 (Add)                (None, 55, 55, 256)          0         ['re_lu_153[0][0]',           
                                                                     'batch_normalization_169[0][0
                                                                    ]']                           
                                                                                                  
 re_lu_156 (ReLU)            (None, 55, 55, 256)          0         ['add_50[0][0]']              
                                                                                                  
 conv2d_170 (Conv2D)         (None, 28, 28, 128)          32896     ['re_lu_156[0][0]']           
                                                                                                  
 batch_normalization_170 (B  (None, 28, 28, 128)          512       ['conv2d_170[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_157 (ReLU)            (None, 28, 28, 128)          0         ['batch_normalization_170[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_171 (Conv2D)         (None, 28, 28, 128)          147584    ['re_lu_157[0][0]']           
                                                                                                  
 batch_normalization_171 (B  (None, 28, 28, 128)          512       ['conv2d_171[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_158 (ReLU)            (None, 28, 28, 128)          0         ['batch_normalization_171[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_173 (Conv2D)         (None, 28, 28, 512)          131584    ['re_lu_156[0][0]']           
                                                                                                  
 conv2d_172 (Conv2D)         (None, 28, 28, 512)          66048     ['re_lu_158[0][0]']           
                                                                                                  
 batch_normalization_173 (B  (None, 28, 28, 512)          2048      ['conv2d_173[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 batch_normalization_172 (B  (None, 28, 28, 512)          2048      ['conv2d_172[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 add_51 (Add)                (None, 28, 28, 512)          0         ['batch_normalization_173[0][0
                                                                    ]',                           
                                                                     'batch_normalization_172[0][0
                                                                    ]']                           
                                                                                                  
 re_lu_159 (ReLU)            (None, 28, 28, 512)          0         ['add_51[0][0]']              
                                                                                                  
 conv2d_174 (Conv2D)         (None, 28, 28, 128)          65664     ['re_lu_159[0][0]']           
                                                                                                  
 batch_normalization_174 (B  (None, 28, 28, 128)          512       ['conv2d_174[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_160 (ReLU)            (None, 28, 28, 128)          0         ['batch_normalization_174[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_175 (Conv2D)         (None, 28, 28, 128)          147584    ['re_lu_160[0][0]']           
                                                                                                  
 batch_normalization_175 (B  (None, 28, 28, 128)          512       ['conv2d_175[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_161 (ReLU)            (None, 28, 28, 128)          0         ['batch_normalization_175[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_176 (Conv2D)         (None, 28, 28, 512)          66048     ['re_lu_161[0][0]']           
                                                                                                  
 batch_normalization_176 (B  (None, 28, 28, 512)          2048      ['conv2d_176[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 add_52 (Add)                (None, 28, 28, 512)          0         ['re_lu_159[0][0]',           
                                                                     'batch_normalization_176[0][0
                                                                    ]']                           
                                                                                                  
 re_lu_162 (ReLU)            (None, 28, 28, 512)          0         ['add_52[0][0]']              
                                                                                                  
 conv2d_177 (Conv2D)         (None, 28, 28, 128)          65664     ['re_lu_162[0][0]']           
                                                                                                  
 batch_normalization_177 (B  (None, 28, 28, 128)          512       ['conv2d_177[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_163 (ReLU)            (None, 28, 28, 128)          0         ['batch_normalization_177[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_178 (Conv2D)         (None, 28, 28, 128)          147584    ['re_lu_163[0][0]']           
                                                                                                  
 batch_normalization_178 (B  (None, 28, 28, 128)          512       ['conv2d_178[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_164 (ReLU)            (None, 28, 28, 128)          0         ['batch_normalization_178[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_179 (Conv2D)         (None, 28, 28, 512)          66048     ['re_lu_164[0][0]']           
                                                                                                  
 batch_normalization_179 (B  (None, 28, 28, 512)          2048      ['conv2d_179[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 add_53 (Add)                (None, 28, 28, 512)          0         ['re_lu_162[0][0]',           
                                                                     'batch_normalization_179[0][0
                                                                    ]']                           
                                                                                                  
 re_lu_165 (ReLU)            (None, 28, 28, 512)          0         ['add_53[0][0]']              
                                                                                                  
 conv2d_180 (Conv2D)         (None, 28, 28, 128)          65664     ['re_lu_165[0][0]']           
                                                                                                  
 batch_normalization_180 (B  (None, 28, 28, 128)          512       ['conv2d_180[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_166 (ReLU)            (None, 28, 28, 128)          0         ['batch_normalization_180[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_181 (Conv2D)         (None, 28, 28, 128)          147584    ['re_lu_166[0][0]']           
                                                                                                  
 batch_normalization_181 (B  (None, 28, 28, 128)          512       ['conv2d_181[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_167 (ReLU)            (None, 28, 28, 128)          0         ['batch_normalization_181[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_182 (Conv2D)         (None, 28, 28, 512)          66048     ['re_lu_167[0][0]']           
                                                                                                  
 batch_normalization_182 (B  (None, 28, 28, 512)          2048      ['conv2d_182[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 add_54 (Add)                (None, 28, 28, 512)          0         ['re_lu_165[0][0]',           
                                                                     'batch_normalization_182[0][0
                                                                    ]']                           
                                                                                                  
 re_lu_168 (ReLU)            (None, 28, 28, 512)          0         ['add_54[0][0]']              
                                                                                                  
 conv2d_183 (Conv2D)         (None, 14, 14, 256)          131328    ['re_lu_168[0][0]']           
                                                                                                  
 batch_normalization_183 (B  (None, 14, 14, 256)          1024      ['conv2d_183[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_169 (ReLU)            (None, 14, 14, 256)          0         ['batch_normalization_183[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_184 (Conv2D)         (None, 14, 14, 256)          590080    ['re_lu_169[0][0]']           
                                                                                                  
 batch_normalization_184 (B  (None, 14, 14, 256)          1024      ['conv2d_184[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_170 (ReLU)            (None, 14, 14, 256)          0         ['batch_normalization_184[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_186 (Conv2D)         (None, 14, 14, 1024)         525312    ['re_lu_168[0][0]']           
                                                                                                  
 conv2d_185 (Conv2D)         (None, 14, 14, 1024)         263168    ['re_lu_170[0][0]']           
                                                                                                  
 batch_normalization_186 (B  (None, 14, 14, 1024)         4096      ['conv2d_186[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 batch_normalization_185 (B  (None, 14, 14, 1024)         4096      ['conv2d_185[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 add_55 (Add)                (None, 14, 14, 1024)         0         ['batch_normalization_186[0][0
                                                                    ]',                           
                                                                     'batch_normalization_185[0][0
                                                                    ]']                           
                                                                                                  
 re_lu_171 (ReLU)            (None, 14, 14, 1024)         0         ['add_55[0][0]']              
                                                                                                  
 conv2d_187 (Conv2D)         (None, 14, 14, 256)          262400    ['re_lu_171[0][0]']           
                                                                                                  
 batch_normalization_187 (B  (None, 14, 14, 256)          1024      ['conv2d_187[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_172 (ReLU)            (None, 14, 14, 256)          0         ['batch_normalization_187[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_188 (Conv2D)         (None, 14, 14, 256)          590080    ['re_lu_172[0][0]']           
                                                                                                  
 batch_normalization_188 (B  (None, 14, 14, 256)          1024      ['conv2d_188[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_173 (ReLU)            (None, 14, 14, 256)          0         ['batch_normalization_188[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_189 (Conv2D)         (None, 14, 14, 1024)         263168    ['re_lu_173[0][0]']           
                                                                                                  
 batch_normalization_189 (B  (None, 14, 14, 1024)         4096      ['conv2d_189[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 add_56 (Add)                (None, 14, 14, 1024)         0         ['re_lu_171[0][0]',           
                                                                     'batch_normalization_189[0][0
                                                                    ]']                           
                                                                                                  
 re_lu_174 (ReLU)            (None, 14, 14, 1024)         0         ['add_56[0][0]']              
                                                                                                  
 conv2d_190 (Conv2D)         (None, 14, 14, 256)          262400    ['re_lu_174[0][0]']           
                                                                                                  
 batch_normalization_190 (B  (None, 14, 14, 256)          1024      ['conv2d_190[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_175 (ReLU)            (None, 14, 14, 256)          0         ['batch_normalization_190[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_191 (Conv2D)         (None, 14, 14, 256)          590080    ['re_lu_175[0][0]']           
                                                                                                  
 batch_normalization_191 (B  (None, 14, 14, 256)          1024      ['conv2d_191[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_176 (ReLU)            (None, 14, 14, 256)          0         ['batch_normalization_191[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_192 (Conv2D)         (None, 14, 14, 1024)         263168    ['re_lu_176[0][0]']           
                                                                                                  
 batch_normalization_192 (B  (None, 14, 14, 1024)         4096      ['conv2d_192[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 add_57 (Add)                (None, 14, 14, 1024)         0         ['re_lu_174[0][0]',           
                                                                     'batch_normalization_192[0][0
                                                                    ]']                           
                                                                                                  
 re_lu_177 (ReLU)            (None, 14, 14, 1024)         0         ['add_57[0][0]']              
                                                                                                  
 conv2d_193 (Conv2D)         (None, 14, 14, 256)          262400    ['re_lu_177[0][0]']           
                                                                                                  
 batch_normalization_193 (B  (None, 14, 14, 256)          1024      ['conv2d_193[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_178 (ReLU)            (None, 14, 14, 256)          0         ['batch_normalization_193[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_194 (Conv2D)         (None, 14, 14, 256)          590080    ['re_lu_178[0][0]']           
                                                                                                  
 batch_normalization_194 (B  (None, 14, 14, 256)          1024      ['conv2d_194[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_179 (ReLU)            (None, 14, 14, 256)          0         ['batch_normalization_194[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_195 (Conv2D)         (None, 14, 14, 1024)         263168    ['re_lu_179[0][0]']           
                                                                                                  
 batch_normalization_195 (B  (None, 14, 14, 1024)         4096      ['conv2d_195[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 add_58 (Add)                (None, 14, 14, 1024)         0         ['re_lu_177[0][0]',           
                                                                     'batch_normalization_195[0][0
                                                                    ]']                           
                                                                                                  
 re_lu_180 (ReLU)            (None, 14, 14, 1024)         0         ['add_58[0][0]']              
                                                                                                  
 conv2d_196 (Conv2D)         (None, 14, 14, 256)          262400    ['re_lu_180[0][0]']           
                                                                                                  
 batch_normalization_196 (B  (None, 14, 14, 256)          1024      ['conv2d_196[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_181 (ReLU)            (None, 14, 14, 256)          0         ['batch_normalization_196[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_197 (Conv2D)         (None, 14, 14, 256)          590080    ['re_lu_181[0][0]']           
                                                                                                  
 batch_normalization_197 (B  (None, 14, 14, 256)          1024      ['conv2d_197[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_182 (ReLU)            (None, 14, 14, 256)          0         ['batch_normalization_197[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_198 (Conv2D)         (None, 14, 14, 1024)         263168    ['re_lu_182[0][0]']           
                                                                                                  
 batch_normalization_198 (B  (None, 14, 14, 1024)         4096      ['conv2d_198[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 add_59 (Add)                (None, 14, 14, 1024)         0         ['re_lu_180[0][0]',           
                                                                     'batch_normalization_198[0][0
                                                                    ]']                           
                                                                                                  
 re_lu_183 (ReLU)            (None, 14, 14, 1024)         0         ['add_59[0][0]']              
                                                                                                  
 conv2d_199 (Conv2D)         (None, 14, 14, 256)          262400    ['re_lu_183[0][0]']           
                                                                                                  
 batch_normalization_199 (B  (None, 14, 14, 256)          1024      ['conv2d_199[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_184 (ReLU)            (None, 14, 14, 256)          0         ['batch_normalization_199[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_200 (Conv2D)         (None, 14, 14, 256)          590080    ['re_lu_184[0][0]']           
                                                                                                  
 batch_normalization_200 (B  (None, 14, 14, 256)          1024      ['conv2d_200[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_185 (ReLU)            (None, 14, 14, 256)          0         ['batch_normalization_200[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_201 (Conv2D)         (None, 14, 14, 1024)         263168    ['re_lu_185[0][0]']           
                                                                                                  
 batch_normalization_201 (B  (None, 14, 14, 1024)         4096      ['conv2d_201[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 add_60 (Add)                (None, 14, 14, 1024)         0         ['re_lu_183[0][0]',           
                                                                     'batch_normalization_201[0][0
                                                                    ]']                           
                                                                                                  
 re_lu_186 (ReLU)            (None, 14, 14, 1024)         0         ['add_60[0][0]']              
                                                                                                  
 conv2d_202 (Conv2D)         (None, 7, 7, 512)            524800    ['re_lu_186[0][0]']           
                                                                                                  
 batch_normalization_202 (B  (None, 7, 7, 512)            2048      ['conv2d_202[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_187 (ReLU)            (None, 7, 7, 512)            0         ['batch_normalization_202[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_203 (Conv2D)         (None, 7, 7, 512)            2359808   ['re_lu_187[0][0]']           
                                                                                                  
 batch_normalization_203 (B  (None, 7, 7, 512)            2048      ['conv2d_203[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_188 (ReLU)            (None, 7, 7, 512)            0         ['batch_normalization_203[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_205 (Conv2D)         (None, 7, 7, 2048)           2099200   ['re_lu_186[0][0]']           
                                                                                                  
 conv2d_204 (Conv2D)         (None, 7, 7, 2048)           1050624   ['re_lu_188[0][0]']           
                                                                                                  
 batch_normalization_205 (B  (None, 7, 7, 2048)           8192      ['conv2d_205[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 batch_normalization_204 (B  (None, 7, 7, 2048)           8192      ['conv2d_204[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 add_61 (Add)                (None, 7, 7, 2048)           0         ['batch_normalization_205[0][0
                                                                    ]',                           
                                                                     'batch_normalization_204[0][0
                                                                    ]']                           
                                                                                                  
 re_lu_189 (ReLU)            (None, 7, 7, 2048)           0         ['add_61[0][0]']              
                                                                                                  
 conv2d_206 (Conv2D)         (None, 7, 7, 512)            1049088   ['re_lu_189[0][0]']           
                                                                                                  
 batch_normalization_206 (B  (None, 7, 7, 512)            2048      ['conv2d_206[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_190 (ReLU)            (None, 7, 7, 512)            0         ['batch_normalization_206[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_207 (Conv2D)         (None, 7, 7, 512)            2359808   ['re_lu_190[0][0]']           
                                                                                                  
 batch_normalization_207 (B  (None, 7, 7, 512)            2048      ['conv2d_207[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_191 (ReLU)            (None, 7, 7, 512)            0         ['batch_normalization_207[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_208 (Conv2D)         (None, 7, 7, 2048)           1050624   ['re_lu_191[0][0]']           
                                                                                                  
 batch_normalization_208 (B  (None, 7, 7, 2048)           8192      ['conv2d_208[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 add_62 (Add)                (None, 7, 7, 2048)           0         ['re_lu_189[0][0]',           
                                                                     'batch_normalization_208[0][0
                                                                    ]']                           
                                                                                                  
 re_lu_192 (ReLU)            (None, 7, 7, 2048)           0         ['add_62[0][0]']              
                                                                                                  
 conv2d_209 (Conv2D)         (None, 7, 7, 512)            1049088   ['re_lu_192[0][0]']           
                                                                                                  
 batch_normalization_209 (B  (None, 7, 7, 512)            2048      ['conv2d_209[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_193 (ReLU)            (None, 7, 7, 512)            0         ['batch_normalization_209[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_210 (Conv2D)         (None, 7, 7, 512)            2359808   ['re_lu_193[0][0]']           
                                                                                                  
 batch_normalization_210 (B  (None, 7, 7, 512)            2048      ['conv2d_210[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_194 (ReLU)            (None, 7, 7, 512)            0         ['batch_normalization_210[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_211 (Conv2D)         (None, 7, 7, 2048)           1050624   ['re_lu_194[0][0]']           
                                                                                                  
 batch_normalization_211 (B  (None, 7, 7, 2048)           8192      ['conv2d_211[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 add_63 (Add)                (None, 7, 7, 2048)           0         ['re_lu_192[0][0]',           
                                                                     'batch_normalization_211[0][0
                                                                    ]']                           
                                                                                                  
 re_lu_195 (ReLU)            (None, 7, 7, 2048)           0         ['add_63[0][0]']              
                                                                                                  
 global_average_pooling2d_3  (None, 2048)                 0         ['re_lu_195[0][0]']           
  (GlobalAveragePooling2D)                                                                        
                                                                                                  
 dense_3 (Dense)             (None, 5)                    10245     ['global_average_pooling2d_3[0
                                                                    ][0]']                        
                                                                                                  
==================================================================================================
Total params: 23597957 (90.02 MB)
Trainable params: 23544837 (89.82 MB)
Non-trainable params: 53120 (207.50 KB)
__________________________________________________________________________________________________
In [65]:
'''
from tensorflow.keras.utils import plot_model

plot_model(model)
'''
# NOTE: Dont run this cell unless you want to visually see a graph of network
Out[65]:
'\nfrom tensorflow.keras.utils import plot_model\n\nplot_model(model)\n'
In [66]:
from tensorflow.keras.optimizers import Adam
#from tensorflow.keras.callbacks import EarlyStopping

model.compile(optimizer=Adam(learning_rate=0.001), loss="categorical_crossentropy", metrics=['accuracy'])

results = model.fit(
    np.array(train_images_augmented), train_labels_one_hot,
    epochs=15, 
    batch_size=32,
    validation_data=(np.array(val_images_augmented), val_labels_one_hot ),
)
Epoch 1/15
13/13 [==============================] - 171s 12s/step - loss: 3.9964 - accuracy: 0.2878 - val_loss: 1.8487 - val_accuracy: 0.3010
Epoch 2/15
13/13 [==============================] - 148s 11s/step - loss: 1.9130 - accuracy: 0.3927 - val_loss: 2.0948 - val_accuracy: 0.2524
Epoch 3/15
13/13 [==============================] - 149s 11s/step - loss: 1.5378 - accuracy: 0.4463 - val_loss: 2.7088 - val_accuracy: 0.3883
Epoch 4/15
13/13 [==============================] - 149s 12s/step - loss: 1.4122 - accuracy: 0.4659 - val_loss: 2.4762 - val_accuracy: 0.3883
Epoch 5/15
13/13 [==============================] - 148s 11s/step - loss: 1.1500 - accuracy: 0.5561 - val_loss: 1.6620 - val_accuracy: 0.3883
Epoch 6/15
13/13 [==============================] - 149s 12s/step - loss: 1.0694 - accuracy: 0.6195 - val_loss: 1.9361 - val_accuracy: 0.3883
Epoch 7/15
13/13 [==============================] - 148s 11s/step - loss: 0.6245 - accuracy: 0.7561 - val_loss: 1.9008 - val_accuracy: 0.3883
Epoch 8/15
13/13 [==============================] - 148s 11s/step - loss: 0.3538 - accuracy: 0.8756 - val_loss: 2.0673 - val_accuracy: 0.2913
Epoch 9/15
13/13 [==============================] - 149s 12s/step - loss: 0.2720 - accuracy: 0.9024 - val_loss: 1.9277 - val_accuracy: 0.3883
Epoch 10/15
13/13 [==============================] - 149s 12s/step - loss: 0.2609 - accuracy: 0.9122 - val_loss: 2.7388 - val_accuracy: 0.3883
Epoch 11/15
13/13 [==============================] - 147s 11s/step - loss: 0.4425 - accuracy: 0.8415 - val_loss: 3.4141 - val_accuracy: 0.2136
Epoch 12/15
13/13 [==============================] - 150s 12s/step - loss: 0.5669 - accuracy: 0.8049 - val_loss: 3.0944 - val_accuracy: 0.2136
Epoch 13/15
13/13 [==============================] - 149s 12s/step - loss: 0.5122 - accuracy: 0.8293 - val_loss: 2.6866 - val_accuracy: 0.2136
Epoch 14/15
13/13 [==============================] - 148s 11s/step - loss: 0.4713 - accuracy: 0.8512 - val_loss: 2.1606 - val_accuracy: 0.2136
Epoch 15/15
13/13 [==============================] - 149s 12s/step - loss: 0.5321 - accuracy: 0.8220 - val_loss: 3.1679 - val_accuracy: 0.2136
In [67]:
#SUBMISSION FILE

pred = model.predict(np.array(test_images_augmented))
test = np.argmax(pred,axis=1)
predicted_labels = [uni_classes[i] for i in test]

submission = [[test_csv["image_id"][i], predicted_labels[i]] for i in range(len(test_csv)) ]
df = pd.DataFrame(submission,columns = ["image_id","label"])

df.to_csv("submission.csv", index=False)

#PLOTTING ACCURACY AND LOSS GRAPHS
fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(10, 4))

axes[0].plot(results.history['accuracy'], label = 'Training')
axes[0].plot(results.history['val_accuracy'], label = 'Validation')

axes[0].set_title("Model accuracy")
axes[0].set_xlabel('Epoch')
axes[0].set_ylabel('Accuracy rate')

axes[0].legend()  

axes[1].plot(results.history['loss'], label = 'Training')
axes[1].plot(results.history['val_loss'], label = 'Validation')

axes[1].set_title("Model loss")
axes[1].set_xlabel('Epoch')
axes[1].set_ylabel('Loss')

training_accuracy = results.history['accuracy']
validation_accuracy = results.history['val_accuracy']

overall_training_accuracy = sum(training_accuracy) / len(training_accuracy)
overall_validation_accuracy = sum(validation_accuracy) / len(validation_accuracy)

print(f"Overall Training Accuracy: {overall_training_accuracy}%")
print(f"Overall Validation Accuracy: {overall_validation_accuracy}%")

plt.legend()  
plt.show()
1/1 [==============================] - 1s 1s/step
Overall Training Accuracy: 0.6908943076928457%
Overall Validation Accuracy: 0.30873786012331644%
No description has been provided for this image